// Copyright (c) 2021, gottingen group.
// All rights reserved.
// Created by liyinbin lijippy@163.com


#ifndef ABEL_CONTAINER_INTERNAL_HASH_POLICY_TESTING_H_
#define ABEL_CONTAINER_INTERNAL_HASH_POLICY_TESTING_H_

#include <cstdlib>
#include <limits>
#include <memory>
#include <ostream>
#include <type_traits>
#include <utility>
#include <vector>

#include "abel/hash/hash.h"
#include <string_view>

namespace abel {

namespace container_internal {
namespace hash_testing_internal {

template<class Derived>
struct WithId {
    WithId() : id_(next_id<Derived>()) {}

    WithId(const WithId &that) : id_(that.id_) {}

    WithId(WithId &&that) : id_(that.id_) { that.id_ = 0; }

    WithId &operator=(const WithId &that) {
        id_ = that.id_;
        return *this;
    }

    WithId &operator=(WithId &&that) {
        id_ = that.id_;
        that.id_ = 0;
        return *this;
    }

    size_t id() const { return id_; }

    friend bool operator==(const WithId &a, const WithId &b) {
        return a.id_ == b.id_;
    }

    friend bool operator!=(const WithId &a, const WithId &b) { return !(a == b); }

  protected:
    explicit WithId(size_t id) : id_(id) {}

  private:
    size_t id_;

    template<class T>
    static size_t next_id() {
        // 0 is reserved for moved from state.
        static size_t gId = 1;
        return gId++;
    }
};

}  // namespace hash_testing_internal

struct NonStandardLayout {
    NonStandardLayout() {}

    explicit NonStandardLayout(std::string s) : value(std::move(s)) {}

    virtual ~NonStandardLayout() {}

    friend bool operator==(const NonStandardLayout &a,
                           const NonStandardLayout &b) {
        return a.value == b.value;
    }

    friend bool operator!=(const NonStandardLayout &a,
                           const NonStandardLayout &b) {
        return a.value != b.value;
    }

    template<typename H>
    friend H abel_hash_value(H h, const NonStandardLayout &v) {
        return H::combine(std::move(h), v.value);
    }

    std::string value;
};

struct StatefulTestingHash
        : abel::container_internal::hash_testing_internal::WithId<
                StatefulTestingHash> {
    template<class T>
    size_t operator()(const T &t) const {
        return abel::hash<T>{}(t);
    }
};

struct StatefulTestingEqual
        : abel::container_internal::hash_testing_internal::WithId<
                StatefulTestingEqual> {
    template<class T, class U>
    bool operator()(const T &t, const U &u) const {
        return t == u;
    }
};

// It is expected that Alloc() == Alloc() for all allocators so we cannot use
// WithId base. We need to explicitly assign ids.
template<class T = int>
struct Alloc : std::allocator<T> {
    using propagate_on_container_swap = std::true_type;

    // Using old paradigm for this to ensure compatibility.
    explicit Alloc(size_t id = 0) : id_(id) {}

    Alloc(const Alloc &) = default;

    Alloc &operator=(const Alloc &) = default;

    template<class U>
    Alloc(const Alloc<U> &that) : std::allocator<T>(that), id_(that.id()) {}

    template<class U>
    struct rebind {
        using other = Alloc<U>;
    };

    size_t id() const { return id_; }

    friend bool operator==(const Alloc &a, const Alloc &b) {
        return a.id_ == b.id_;
    }

    friend bool operator!=(const Alloc &a, const Alloc &b) { return !(a == b); }

  private:
    size_t id_ = (std::numeric_limits<size_t>::max)();
};

template<class Map>
auto items(const Map &m) -> std::vector<
        std::pair<typename Map::key_type, typename Map::mapped_type>> {
    using std::get;
    std::vector<std::pair<typename Map::key_type, typename Map::mapped_type>> res;
    res.reserve(m.size());
    for (const auto &v : m)
        res.emplace_back(get<0>(v), get<1>(v));
    return res;
}

template<class Set>
auto keys(const Set &s)
-> std::vector<typename std::decay<typename Set::key_type>::type> {
    std::vector<typename std::decay<typename Set::key_type>::type> res;
    res.reserve(s.size());
    for (const auto &v : s)
        res.emplace_back(v);
    return res;
}

}  // namespace container_internal

}  // namespace abel

// ABEL_UNORDERED_SUPPORTS_ALLOC_CTORS is false for glibcxx versions
// where the unordered containers are missing certain constructors that
// take allocator arguments. This test is defined ad-hoc for the platforms
// we care about (notably Crosstool 17) because libstdcxx's useless
// versioning scheme precludes a more principled solution.
// From GCC-4.9 Changelog: (src: https://gcc.gnu.org/gcc-4.9/changes.html)
// "the unordered associative containers in <unordered_map> and <unordered_set>
// meet the allocator-aware container requirements;"
#if (defined(__GLIBCXX__) && __GLIBCXX__ <= 20140425) || \
(__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 9))
#define ABEL_UNORDERED_SUPPORTS_ALLOC_CTORS 0
#else
#define ABEL_UNORDERED_SUPPORTS_ALLOC_CTORS 1
#endif

#endif  // ABEL_CONTAINER_INTERNAL_HASH_POLICY_TESTING_H_
